import { sendMessage, getMessageList, markMessageAsRead } from '@/api/secondVitim/message'

/**
 * 消息管理工具类
 */
class MessageManager {
  constructor() {
    this.pollingTimer = null
    this.pollingInterval = 5000 // 5秒轮询一次
    this.lastMessageTime = null
  }

  /**
   * 发送消息到服务器
   * @param {Object} messageData 消息数据
   * @returns {Promise}
   */
  async sendMessageToServer(messageData) {
    try {
      const response = await sendMessage({
        senderId: messageData.senderId,
        senderName: messageData.senderName,
        senderType: messageData.senderType,
        receiverId: messageData.receiverId,
        receiverName: messageData.receiverName,
        receiverType: messageData.receiverType,
        nurseId: messageData.nurseId,
        nurseName: messageData.nurseName,
        content: messageData.content,
        timestamp: messageData.timestamp
      })
      
      // 如果服务器返回了消息ID，更新本地消息
      if (response.data && response.data.id) {
        return response.data
      }
      return messageData
    } catch (error) {
      console.error('发送消息失败:', error)
      // 即使发送失败，也返回本地消息对象，保证UI正常显示
      return messageData
    }
  }

  /**
   * 从服务器获取新消息
   * @param {String} userId 当前用户ID
   * @param {String} lastTime 最后一条消息的时间戳
   * @returns {Promise<Array>}
   */
  async fetchNewMessages(userId, lastTime = null) {
    try {
      const params = {
        pageNum: 1,
        pageSize: 50
      }
      
      // 获取发送给当前用户的消息（作为接收者）
      // 同时也获取当前用户发送的消息（用于同步服务器端的状态）
      if (lastTime) {
        params.startTime = lastTime
      }
      
      // 获取接收者是当前用户的消息（别人发给我的）
      const response = await getMessageList({
        ...params,
        receiverId: userId
      })
      
      let newMessages = []
      if (response.rows && response.rows.length > 0) {
        newMessages = response.rows
      }
      
      // 如果指定了lastTime，只返回比lastTime更新的消息
      if (lastTime && newMessages.length > 0) {
        newMessages = newMessages.filter(msg => {
          return new Date(msg.timestamp) > new Date(lastTime)
        })
      }
      
      return newMessages
    } catch (error) {
      console.error('获取新消息失败:', error)
      return []
    }
  }

  /**
   * 同步消息到本地存储
   * @param {Array} newMessages 新消息列表
   */
  syncMessagesToLocal(newMessages) {
    if (!newMessages || newMessages.length === 0) {
      return
    }

    const allMessages = uni.getStorageSync('all_messages') || []
    const messageMap = new Map()
    
    // 将现有消息转为Map，以ID为key
    allMessages.forEach(msg => {
      messageMap.set(msg.id, msg)
    })
    
    // 合并新消息
    newMessages.forEach(msg => {
      if (!messageMap.has(msg.id)) {
        messageMap.set(msg.id, msg)
      }
    })
    
    // 转回数组并保存
    const updatedMessages = Array.from(messageMap.values())
    uni.setStorageSync('all_messages', updatedMessages)
    
    // 触发消息更新事件
    uni.$emit('message-updated', { newMessages })
    
    return updatedMessages
  }

  /**
   * 标记消息为已读
   * @param {Array} messageIds 消息ID数组
   */
  async markMessagesAsRead(messageIds) {
    if (!messageIds || messageIds.length === 0) {
      return
    }
    
    try {
      await markMessageAsRead(messageIds)
      
      // 更新本地存储中的消息状态
      const allMessages = uni.getStorageSync('all_messages') || []
      allMessages.forEach(msg => {
        if (messageIds.includes(msg.id)) {
          msg.isRead = true
        }
      })
      uni.setStorageSync('all_messages', allMessages)
    } catch (error) {
      console.error('标记消息已读失败:', error)
    }
  }

  /**
   * 开始消息轮询
   * @param {String} userId 当前用户ID
   */
  startPolling(userId) {
    if (this.pollingTimer) {
      this.stopPolling()
    }
    
    // 立即执行一次
    this.pollMessages(userId)
    
    // 设置定时轮询
    this.pollingTimer = setInterval(() => {
      this.pollMessages(userId)
    }, this.pollingInterval)
  }

  /**
   * 停止消息轮询
   */
  stopPolling() {
    if (this.pollingTimer) {
      clearInterval(this.pollingTimer)
      this.pollingTimer = null
    }
  }

  /**
   * 轮询获取消息
   * @param {String} userId 当前用户ID
   */
  async pollMessages(userId) {
    if (!userId) {
      return
    }
    
    try {
      // 获取最后一条消息的时间
      const allMessages = uni.getStorageSync('all_messages') || []
      let lastTime = this.lastMessageTime
      
      if (allMessages.length > 0) {
        // 找到最新的消息时间
        const sortedMessages = allMessages.sort((a, b) => {
          return new Date(b.timestamp) - new Date(a.timestamp)
        })
        lastTime = sortedMessages[0].timestamp
      }
      
      // 获取新消息
      const newMessages = await this.fetchNewMessages(userId, lastTime)
      
      if (newMessages.length > 0) {
        // 同步到本地
        this.syncMessagesToLocal(newMessages)
        
        // 更新最后消息时间
        if (newMessages.length > 0) {
          const latestMessage = newMessages.sort((a, b) => {
            return new Date(b.timestamp) - new Date(a.timestamp)
          })[0]
          this.lastMessageTime = latestMessage.timestamp
        }
        
        // 显示新消息提示（可选）
        // uni.showToast({
        //   title: `收到${newMessages.length}条新消息`,
        //   icon: 'none'
        // })
      }
    } catch (error) {
      console.error('轮询消息失败:', error)
    }
  }
}

// 导出单例
export default new MessageManager()

